/**
 * king
 */
package cn.scau.info.chao;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

/**
 * @author king
 *
 */
public class Test {
	/** 
	 * 随机指定范围内N个不重复的数 
	 * 利用HashSet的特征，只能存放不同的值 
	 * @param min 指定范围最小值 
	 * @param max 指定范围最大值 
	 * @param n 随机数个数 
	 * @param HashSet<Integer> set 随机数结果集 
	 */  
	   public static void randomSet(int min, int max, int n, LinkedHashSet<Integer> set) {  
	       if (n > (max - min + 1) || max < min) {  
	           return;  
	       }  
	       for (int i = 0; i < n; i++) {  
	           // 调用Math.random()方法  
	           int num = (int) (Math.random() * (max - min)) + min;  
	           set.add(num);// 将不同的数存入HashSet中  
	       }  
	       int setSize = set.size();  
	       // 如果存入的数小于指定生成的个数，则调用递归再生成剩余个数的随机数，如此循环，直到达到指定大小  
	       if (setSize < n) {  
	        randomSet(min, max, n , set);// 递归  
	       }  
	   }  
	   
	   /** 
	    * 随机指定范围内N个不重复的数 
	    * 最简单最基本的方法 
	    * @param min 指定范围最小值 
	    * @param max 指定范围最大值 
	    * @param n 随机数个数 
	    */  
	   public static int[] randomCommon(int min, int max, int n){  
	       if (n > (max - min + 1) || max < min) {  
	              return null;  
	          }  
	       int[] result = new int[n];  
	       int count = 0;  
	       while(count < n) {  
	           int num = (int) (Math.random() * (max - min)) + min;  
	           boolean flag = true;  
	           for (int j = 0; j < n; j++) {  
	               if(num == result[j]){  
	                   flag = false;  
	                   break;  
	               }  
	           }  
	           if(flag){  
	               result[count] = num;  
	               count++;  
	           }  
	       }  
	       return result;  
	   }  
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		System.out.println(Math.ceil(49/5));
	}
	public static Map<Integer, Double> sortMapByValue(Map<Integer, Double> oriMap) {  
	    Map<Integer, Double> sortedMap = new LinkedHashMap<Integer, Double>();  
	    if (oriMap != null && !oriMap.isEmpty()) {  
	        List<Map.Entry<Integer, Double>> entryList = new ArrayList<Map.Entry<Integer, Double>>(oriMap.entrySet());  
	        Collections.sort(entryList,  
	                new Comparator<Map.Entry<Integer, Double>>() {  
	                    public int compare(Entry<Integer, Double> entry1,  
	                            Entry<Integer, Double> entry2) {  
	                        double value1 = entry1.getValue(), value2 = entry2.getValue();  
	                        
	                        return (int) (value2 - value1);  
	                    }  
	                });  
	        Iterator<Map.Entry<Integer, Double>> iter = entryList.iterator();  
	        Map.Entry<Integer, Double> tmpEntry = null;  
	        while (iter.hasNext()) {  
	            tmpEntry = iter.next();  
	            sortedMap.put(tmpEntry.getKey(), tmpEntry.getValue());  
	        }  
	    }  
	    return sortedMap;  
	}  
}
